package com.ce.cetag.util;

import java.io.UnsupportedEncodingException;
import java.util.StringTokenizer;
import java.util.Iterator;
import java.net.URLEncoder;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.StringEscapeUtils;

/**
 * 字符串处理方法大全 主要方法包括：
 * <ul>
 * <li>unicodeToGB － 由"GBK"码转换为"ISO8859_1"码
 * <li>GBToUnicode － 由"ISO8859_1"码转换为"GBK"码
 * <li>replace - 在字符串中进行查找替换，给出替换后的字符串(update)
 * <li>split - 使用给定的分隔符拆分字符串成字符串数组(new);
 * <li>join - 组合数据结构中所有元素成一个字符串(new);
 * <li>repeat - 重复多次组合成新的字符串(new);
 * <li>is... - 检查字符串中包含的字符的类型(new);
 * <li>defaultString - 返回默认的字符串，将null变为空白字符(new);
 * <li>htmlEncode - 在字符串中替换html标记所用的六个特殊字符：& \ " ' &lt; &gt;
 * <li>return2Br - 将字符串中的换行符"\n"转换为html换行标记"&lt;br&gt;"
 * <li>blank2NBSP - 将字符串中的空格" "转换为html的空格标记"&amp;nbsp;"
 * <li>urlEncodeNPath - 能解决一些路径中的文件名包含中文的问题
 * <li>cutShort - 使用省略号(...)将过长的字符串截短
 * <li>htmlCutShort - 使用省略号(...)将过长的字符串截短并转码html中的特殊字符
 * <li>escapeHtml - 使用HTML entities中出现的字符，将字符串中的需要转换的字符全部逃逸
 * <li>unescapeHtml - escapeHtml的反操作
 * <li>escapeXml - 使用XML entities中出现四个常用的字符，将字符串中的需要转换的字符全部逃逸
 * <li>unescapeXml - escapeXml的反操作
 * <li>toToken - 除去字符串中的所有逗号分割符
 * <li>toToken - 除去字符串中的所有指定的分割符
 * <li>leftTrim - 将字符串左边的所有空格去掉。
 * <li>rightTrim - 将字符串右边的所有空格去掉。
 * <li>leftTrim - 将字符串左边的所有空格去掉。
 * <li>reverseString - 反转字符串。
 * <li>convertStr - 主要用于cetree组装节点,如果字符串中含有'符号,在前台的js中会出现异常
 * 该方法对含'的字符进行转换,供前台js使用,即把 ' 转化为: \'
 * </ul>
 */
public class StringUtil {

	public StringUtil() {
	}

	/**
	 * 转换中文字符集，由"GBK"码转换为"ISO8859_1"码。
	 *
	 * @param sSource
	 *            需要转换的字符串。
	 * @return 返回转换后的字符串。
	 */
	public static String unicodeToGB(String sSource)
			throws UnsupportedEncodingException {
		try {
			String S_Desc = "";
			if (sSource != null && !sSource.trim().equals("")) {
				byte b_Proc[] = sSource.getBytes("GBK");
				S_Desc = new String(b_Proc, "ISO8859_1");
			}
			return S_Desc;
		} catch (UnsupportedEncodingException e) {
			throw e;
			// EncodingException encode = new EncodingException(e.getMessage());
			// encode.setMessageCode("resource_StringUtil_002");
			// encode.setExtandMessage("GBK");
			// throw encode;
		}
	}

	/**
	 * 转换中文字符集，由"ISO8859_1"码转换为"GBK"码。
	 *
	 * @param sSource
	 *            需要转换的字符串。
	 * @return 返回转换后的字符串。
	 */
	public static String GBToUnicode(String sSource)
			throws UnsupportedEncodingException {
		try {
			String S_Desc = "";
			if (sSource != null && !sSource.trim().equals("")) {
				byte b_Proc[] = sSource.getBytes("ISO8859_1");
				S_Desc = new String(b_Proc, "GBK");
			}
			return S_Desc;
		} catch (UnsupportedEncodingException e) {
			throw e;
			// EncodingException encode = new EncodingException(e.getMessage());
			// encode.setMessageCode("resource_StringUtil_002");
			// encode.setExtandMessage("GBK");
			// throw encode;
		}
	}

	/**
	 * 在字符串中进行查找替换，给出替换后的字符串.
	 *
	 * 如果是null 传入将返回不替换而返回原字符串. 例子：
	 *
	 * <pre>
	 *  StringUtil.replace(null, *, *)        = null
	 *  StringUtil.replace(&quot;&quot;, *, *)          = &quot;&quot;
	 *  StringUtil.replace(&quot;aba&quot;, null, null) = &quot;aba&quot;
	 *  StringUtil.replace(&quot;aba&quot;, null, null) = &quot;aba&quot;
	 *  StringUtil.replace(&quot;aba&quot;, &quot;a&quot;, null)  = &quot;aba&quot;
	 *  StringUtil.replace(&quot;aba&quot;, &quot;a&quot;, &quot;&quot;)    = &quot;aba&quot;
	 *  StringUtil.replace(&quot;aba&quot;, &quot;a&quot;, &quot;z&quot;)   = &quot;zbz&quot;
	 * </pre>
	 *
	 * @param text
	 *            text to search and replace in, may be null
	 * @param repl
	 *            the String to search for, may be null
	 * @param with
	 *            the String to replace with, may be null
	 * @return the text with any replacements processed, <code>null</code> if
	 *         null String input
	 */
	public static String replace(String text, String repl, String with) {
		return StringUtils.replace(text, repl, with);
	}

	/**
	 * 在字符串中替换html标记所用的六个特殊字符：& \ " ' &lt; &gt;
	 *
	 * @param sSource
	 *            要替换的字符串。
	 * @return 返回替换后的字符串。
	 */
	public static String htmlEncode(String sSource) {
		String sTemp = sSource;
		sTemp = replace(sTemp, "&", "&amp;");
		sTemp = replace(sTemp, "\"", "&quot;");
		sTemp = replace(sTemp, "'", "&#039;");
		sTemp = replace(sTemp, "<", "&lt;");
		sTemp = replace(sTemp, ">", "&gt;");
		return sTemp;
	}

	/**
	 * 在字符串中替换html标记所用的六个特殊字符： " ';
	 *
	 * @param sSource
	 *            要替换的字符串。
	 * @return 返回替换后的字符串。
	 */
	public static String replaceQuotation(String sSource) {
		String sTemp = sSource;
		sTemp = replace(sTemp, "\"", "\\\"");
		sTemp = replace(sTemp, "'", "\\\'");
		return sTemp;
	}

	/**
	 * 将字符串中的换行符"\n"转换为html换行标记"&lt;br&gt;"
	 *
	 * @param sSource
	 *            要替换的字符串。
	 * @return 返回替换后的字符串。
	 */
	public static String return2Br(String sSource) {
		return replace(sSource, "\n", "<br>");
	}

	/**
	 * 将字符串中的空格" "转换为html的空格标记"&amp;nbsp;"
	 *
	 * @param sSource
	 *            要替换的字符串。
	 * @return 返回替换后的字符串。
	 */
	public static String blank2NBSP(String sSource) {
		return replace(sSource, " ", "&nbsp;");
	}

	/**
	 * 使用给定的分隔符将传入的字符串分割成字符串数组.
	 *
	 * 分隔符不包括在返回的字符串数组中.相邻的分隔符作为一个分隔符处理
	 *
	 * A <code>null</code> input String returns <code>null</code>. 例子：
	 *
	 * <pre>
	 *  StringUtil.split(null, *)         = null
	 *  StringUtil.split(&quot;&quot;, *)           = []
	 *  StringUtil.split(&quot;a.b.c&quot;, '.')    = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
	 *  StringUtil.split(&quot;a..b.c&quot;, '.')   = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
	 *  StringUtil.split(&quot;a:b:c&quot;, '.')    = [&quot;a:b:c&quot;]
	 *  StringUtil.split(&quot;a\tb\nc&quot;, null) = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
	 *  StringUtil.split(&quot;a b c&quot;, ' ')    = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
	 * </pre>
	 *
	 * @param str
	 *            the String to parse, may be null
	 * @param separatorChar
	 *            the character used as the delimiter, <code>null</code>
	 *            splits on whitespace
	 * @return an array of parsed Strings, <code>null</code> if null String
	 *         input
	 */
	public static String[] split(String str, char separatorChar) {
		return StringUtils.split(str, separatorChar);
	}

	/**
	 * 使用给定的分隔符将传入的字符串分割成字符串数组. 分隔符不包括在返回的字符串数组中.相邻的分隔符作为一个分隔符处理
	 *
	 * <p>
	 * A <code>null</code> input String returns <code>null</code>. A
	 * <code>null</code> separatorChars splits on whitespace.
	 * </p>
	 * 例子：
	 *
	 * <pre>
	 *  StringUtil.split(null, *)         = null
	 *  StringUtil.split(&quot;&quot;, *)           = []
	 *  StringUtil.split(&quot;abc def&quot;, null) = [&quot;abc&quot;, &quot;def&quot;]
	 *  StringUtil.split(&quot;abc def&quot;, &quot; &quot;)  = [&quot;abc&quot;, &quot;def&quot;]
	 *  StringUtil.split(&quot;abc  def&quot;, &quot; &quot;) = [&quot;abc&quot;, &quot;def&quot;]
	 *  StringUtil.split(&quot;ab:cd:ef&quot;, &quot;:&quot;) = [&quot;ab&quot;, &quot;cd&quot;, &quot;ef&quot;]
	 * </pre>
	 *
	 * @param str
	 *            the String to parse, may be null
	 * @param separatorChars
	 *            the characters used as the delimiters, <code>null</code>
	 *            splits on whitespace
	 * @return an array of parsed Strings, <code>null</code> if null String
	 *         input
	 */
	public static String[] split(String str, String separatorChars) {
		return StringUtils.split(str, separatorChars);
	}

	/**
	 * 把一个传入的字符串重复 <code>repeat</code> 次,然后组成一个新的字符串. 例子：
	 *
	 * <pre>
	 *  StringUtil.repeat(null, 2) = null
	 *  StringUtil.repeat(&quot;&quot;, 0)   = &quot;&quot;
	 *  StringUtil.repeat(&quot;&quot;, 2)   = &quot;&quot;
	 *  StringUtil.repeat(&quot;a&quot;, 3)  = &quot;aaa&quot;
	 *  StringUtil.repeat(&quot;ab&quot;, 2) = &quot;abab&quot;
	 *  StringUtil.repeat(&quot;a&quot;, -2) = &quot;&quot;
	 * </pre>
	 *
	 * @param str
	 *            the String to repeat, may be null
	 * @param repeat
	 *            number of times to repeat str, negative treated as zero
	 * @return a new String consisting of the original String repeated,
	 *         <code>null</code> if null String input
	 */
	public static String repeat(String str, int repeat) {
		return StringUtils.repeat(str, repeat);
	}

	/**
	 * <p>
	 * 将提供的数组中的元素组合成一个字符串.
	 * </p>
	 *
	 * <p>
	 * No separator is added to the joined String. Null objects or empty strings
	 * within the array are represented by empty strings.
	 * </p>
	 * 例子：
	 *
	 * <pre>
	 *  StringUtil.join(null)            = null
	 *  StringUtil.join([])              = &quot;&quot;
	 *  StringUtil.join([null])          = &quot;&quot;
	 *  StringUtil.join([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]) = &quot;abc&quot;
	 *  StringUtil.join([null, &quot;&quot;, &quot;a&quot;]) = &quot;a&quot;
	 * </pre>
	 *
	 * @param array
	 *            the array of values to join together, may be null
	 * @return the joined String, <code>null</code> if null array input
	 */
	public static String join(Object[] array) {
		return StringUtils.join(array);
	}

	/**
	 * <p>
	 * 将提供的数组中的元素组合成一个字符串.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty
	 * strings within the array are represented by empty strings.
	 * </p>
	 * 例子:
	 *
	 * <pre>
	 *  StringUtil.join(null, *)               = null
	 *  StringUtil.join([], *)                 = &quot;&quot;
	 *  StringUtil.join([null], *)             = &quot;&quot;
	 *  StringUtil.join([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;], ';')  = &quot;a;b;c&quot;
	 *  StringUtil.join([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;], null) = &quot;abc&quot;
	 *  StringUtil.join([null, &quot;&quot;, &quot;a&quot;], ';')  = &quot;;;a&quot;
	 * </pre>
	 *
	 * @param array
	 *            the array of values to join together, may be null
	 * @param separator
	 *            the separator character to use
	 * @return the joined String, <code>null</code> if null array input
	 */
	public static String join(Object[] array, char separator) {
		return StringUtils.join(array, separator);
	}

	/**
	 * <p>
	 * 将提供的数组中的元素组合成一个字符串.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. A <code>null</code>
	 * separator is the same as an empty String (""). Null objects or empty
	 * strings within the array are represented by empty strings.
	 * </p>
	 * 例子：
	 *
	 * <pre>
	 *  StringUtil.join(null, *)                = null
	 *  StringUtil.join([], *)                  = &quot;&quot;
	 *  StringUtil.join([null], *)              = &quot;&quot;
	 *  StringUtil.join([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;], &quot;--&quot;)  = &quot;a--b--c&quot;
	 *  StringUtil.join([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;], null)  = &quot;abc&quot;
	 *  StringUtil.join([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;], &quot;&quot;)    = &quot;abc&quot;
	 *  StringUtil.join([null, &quot;&quot;, &quot;a&quot;], ',')   = &quot;,,a&quot;
	 * </pre>
	 *
	 * @param array
	 *            the array of values to join together, may be null
	 * @param separator
	 *            the separator character to use, null treated as ""
	 * @return the joined String, <code>null</code> if null array input
	 */
	public static String join(Object[] array, String separator) {
		return StringUtils.join(array, separator);
	}

	/**
	 * <p>
	 * 将提供的 <code>Iterator</code>中的元素组合成一个字符串.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. Null objects or empty
	 * strings within the iteration are represented by empty strings.
	 * </p>
	 *
	 * <p>
	 * See the examples here: {@link #join(Object[],char)}.
	 * </p>
	 *
	 * @param iterator
	 *            the <code>Iterator</code> of values to join together, may be
	 *            null
	 * @param separator
	 *            the separator character to use
	 * @return the joined String, <code>null</code> if null iterator input
	 */
	public static String join(Iterator iterator, char separator) {
		return StringUtils.join(iterator, separator);
	}

	/**
	 * <p>
	 * 将提供的 <code>Iterator</code>中的元素组合成一个字符串.
	 * </p>
	 *
	 * <p>
	 * No delimiter is added before or after the list. A <code>null</code>
	 * separator is the same as an empty String ("").
	 * </p>
	 *
	 * <p>
	 * See the examples here: {@link #join(Object[],String)}.
	 * </p>
	 *
	 * @param iterator
	 *            the <code>Iterator</code> of values to join together, may be
	 *            null
	 * @param separator
	 *            the separator character to use, null treated as ""
	 * @return the joined String, <code>null</code> if null iterator input
	 */
	public static String join(Iterator iterator, String separator) {
		return StringUtils.join(iterator, separator);
	}

	/**
	 * <p>
	 * 检查是否字符串仅包含字母.
	 * </p>
	 *
	 * <p>
	 * <code>null</code> will return <code>false</code>. An empty String
	 * ("") will return <code>true</code>.
	 * </p>
	 * 例子：
	 *
	 * <pre>
	 *  StringUtil.isAlpha(null)   = false
	 *  StringUtil.isAlpha(&quot;&quot;)     = true
	 *  StringUtil.isAlpha(&quot;  &quot;)   = false
	 *  StringUtil.isAlpha(&quot;abc&quot;)  = true
	 *  StringUtil.isAlpha(&quot;ab2c&quot;) = false
	 *  StringUtil.isAlpha(&quot;ab-c&quot;) = false
	 * </pre>
	 *
	 * @param str
	 *            the String to check, may be null
	 * @return <code>true</code> if only contains letters, and is non-null
	 */
	public static boolean isAlpha(String str) {
		return StringUtils.isAlpha(str);
	}

	/**
	 * <p>
	 * 检查是否字符串仅包含字母或数字.
	 * </p>
	 *
	 * <p>
	 * <code>null</code> will return <code>false</code>. An empty String
	 * ("") will return <code>true</code>.
	 * </p>
	 * 例子：
	 *
	 * <pre>
	 *  StringUtil.isAlphanumeric(null)   = false
	 *  StringUtil.isAlphanumeric(&quot;&quot;)     = true
	 *  StringUtil.isAlphanumeric(&quot;  &quot;)   = false
	 *  StringUtil.isAlphanumeric(&quot;abc&quot;)  = true
	 *  StringUtil.isAlphanumeric(&quot;ab c&quot;) = false
	 *  StringUtil.isAlphanumeric(&quot;ab2c&quot;) = true
	 *  StringUtil.isAlphanumeric(&quot;ab-c&quot;) = false
	 * </pre>
	 *
	 * @param str
	 *            the String to check, may be null
	 * @return <code>true</code> if only contains letters or digits, and is
	 *         non-null
	 */
	public static boolean isAlphanumeric(String str) {
		return StringUtils.isAlphanumeric(str);
	}

	/**
	 * <p>
	 * 检查是否字符串仅包含数字，浮点数不是一个数字，所以返回false.
	 * </p>
	 *
	 * <p>
	 * <code>null</code> will return <code>false</code>. An empty String
	 * ("") will return <code>true</code>.
	 * </p>
	 * 例子：
	 *
	 * <pre>
	 *  StringUtil.isNumeric(null)   = false
	 *  StringUtil.isNumeric(&quot;&quot;)     = true
	 *  StringUtil.isNumeric(&quot;  &quot;)   = false
	 *  StringUtil.isNumeric(&quot;123&quot;)  = true
	 *  StringUtil.isNumeric(&quot;12 3&quot;) = false
	 *  StringUtil.isNumeric(&quot;ab2c&quot;) = false
	 *  StringUtil.isNumeric(&quot;12-3&quot;) = false
	 *  StringUtil.isNumeric(&quot;12.3&quot;) = false
	 * </pre>
	 *
	 * @param str
	 *            the String to check, may be null
	 * @return <code>true</code> if only contains digits, and is non-null
	 */
	public static boolean isNumeric(String str) {
		return StringUtils.isNumeric(str);
	}

	/**
	 * <p>
	 * 检查是否字符串仅包含空白.
	 * </p>
	 *
	 * <p>
	 * <code>null</code> will return <code>false</code>. An empty String
	 * ("") will return <code>true</code>.
	 * </p>
	 * 例子：
	 *
	 * <pre>
	 *  StringUtil.isWhitespace(null)   = false
	 *  StringUtil.isWhitespace(&quot;&quot;)     = true
	 *  StringUtil.isWhitespace(&quot;  &quot;)   = true
	 *  StringUtil.isWhitespace(&quot;abc&quot;)  = false
	 *  StringUtil.isWhitespace(&quot;ab2c&quot;) = false
	 *  StringUtil.isWhitespace(&quot;ab-c&quot;) = false
	 * </pre>
	 *
	 * @param str
	 *            the String to check, may be null
	 * @return <code>true</code> if only contains whitespace, and is non-null
	 */
	public static boolean isWhitespace(String str) {
		return StringUtils.isWhitespace(str);
	}

	/**
	 * <p>
	 * 返回原字符串，当传入的字符串是<code>null</code>时, 返回空字符串("").
	 * </p>
	 * 例子:
	 *
	 * <pre>
	 *  StringUtil.defaultString(null)  = &quot;&quot;
	 *  StringUtil.defaultString(&quot;&quot;)    = &quot;&quot;
	 *  StringUtil.defaultString(&quot;bat&quot;) = &quot;bat&quot;
	 * </pre>
	 *
	 * @param str
	 *            the String to check, may be null
	 * @return the passed in String, or the empty String if it was
	 *         <code>null</code>
	 */
	public static String defaultString(String str) {
		return StringUtils.defaultString(str);
	}

	/**
	 * <p>
	 * 返回原字符串，当传入的字符串是<code>null</code>或者为空字符串时, 返回输入的默认值.
	 * </p>
	 * 例子：
	 *
	 * <pre>
	 *  StringUtil.defaultString(null, &quot;null&quot;)  = &quot;null&quot;
	 *  StringUtil.defaultString(&quot;&quot;, &quot;null&quot;)    = &quot;null&quot;
	 *  StringUtil.defaultString(&quot;bat&quot;, &quot;null&quot;) = &quot;bat&quot;
	 * </pre>
	 *
	 * @param str
	 *            the String to check, may be null
	 * @param defaultStr
	 *            the default String to return if the input is <code>null</code>,
	 *            may be null
	 * @return the passed in String, or the default if it was <code>null</code>
	 *         or empty string.
	 */
	public static String defaultString(String str, String defaultStr) {
		if (str == null || str.equals("")) {
			return defaultStr;
		} else {
			return str;
		}
	}

	/**
	 * 将路径中的文件名单独取出并用URLEncode编码然后组成新的路径,能解决一些路径中的文件名包含中文的问题
	 *
	 * @param path
	 *            路径字符串
	 * @return 返回编码后的路径字符串，如果参数为空或者长度为0返回0长度字符串
	 */
	public static String urlEncodeNPath(String path) {
		String fileName = "", prefix = "", suffix = "";
		if (path == null || path.trim().length() == 0)
			return "";
		int intDot = path.lastIndexOf(".");
		int intSlash = path.lastIndexOf("/");
		// 取最靠后的正斜杠或者反斜杠
		intSlash = (intSlash >= path.lastIndexOf("\\")) ? intSlash : path
				.lastIndexOf("\\");
		if (intSlash == -1)
			intSlash = 0;
		else
			intSlash = intSlash + 1;

		if (intDot > intSlash)
			suffix = path.substring(intDot, path.length());

		// System.out.println("suffix: " + suffix);
		prefix = path.substring(0, intSlash);
		// System.out.println("prefix: " + prefix);
		if (intDot > intSlash)
			fileName = path.substring(intSlash, intDot);
		else
			fileName = path.substring(intSlash, path.length());
		// System.out.println("filename: " + fileName);
		String temp = "";
		try {
			temp = prefix + URLEncoder.encode(fileName, "GBK") + suffix;
		} catch (Exception e) {
		}

		return temp;
	}

	/**
	 * 使用省略号(...)将过长的字符串截短。
	 *
	 * 使用注意: 如果str的长度短于maxWidth个字符个数，返回str本身.
	 * 如果str的长度长于maxWidth个字符个数，将被截短到(substring(str, 0, max-3) + "...")
	 * 如果maxWidth小于4, 异常IllegalArgumentException将会抛出. 返回的字符串的长度永远不会长于maxWidth
	 *
	 * <pre>
	 *  StringUtil.cutShort(null, *)      = null
	 *  StringUtil.cutShort(&quot;&quot;, 4)        = &quot;&quot;
	 *  StringUtil.cutShort(&quot;abcdefg&quot;, 6) = &quot;abc...&quot;
	 *  StringUtil.cutShort(&quot;abcdefg&quot;, 7) = &quot;abcdefg&quot;
	 *  StringUtil.cutShort(&quot;abcdefg&quot;, 8) = &quot;abcdefg&quot;
	 *  StringUtil.cutShort(&quot;abcdefg&quot;, 4) = &quot;a...&quot;
	 *  StringUtil.cutShort(&quot;abcdefg&quot;, 3) = IllegalArgumentException
	 * </pre>
	 *
	 * @param str
	 *            要被截短的字符串,可以为 null
	 * @param maxWidth
	 *            截短后字符串的最大长度, 但必须大于等于 4
	 * @return 截短后的字符串, 如果传入null字符串则返回<code>null</code>
	 * @throws IllegalArgumentException
	 *             如果长度小于 4
	 */
	public static String cutShort(String str, int maxWidth)
			throws IllegalArgumentException {
		try {
			return StringUtils.abbreviate(str, 0, maxWidth);

		} catch (IllegalArgumentException e) {
			throw e;
			// IllegalArgumentOfException ille = new
			// IllegalArgumentOfException(e.getMessage());
			// ille.setMessageCode("resource_StringUtil_001");
			// throw ille;
		}
	}

	/**
	 * 使用省略号(...)将过长的字符串截短并转码html中的特殊字符
	 *
	 * @param str
	 *            要被截短的字符串,可以为 null
	 * @param maxWidth
	 *            截短后字符串的最大长度, 但必须大于等于 4
	 * @return 截短后并转码了html中的特殊字符的字符串, 如果传入null字符串则返回<code>null</code>
	 * @throws IllegalArgumentException
	 *             如果长度小于 4
	 */
	public static String htmlCutShort(String str, int maxWidth)
			throws IllegalArgumentException {
		try {
			return htmlEncode(cutShort(str, maxWidth));
		} catch (IllegalArgumentException e) {
			throw e;
			// IllegalArgumentOfException ille = new
			// IllegalArgumentOfException(e.getMessage());
			// ille.setMessageCode("resource_StringUtil_001");
			// throw ille;
		}
	}

	/**
	 * 使用HTML entities中出现的字符，将字符串中的需要转换的字符全部逃逸. 例如: <tt>"bread" & "butter"</tt> =>
	 * <tt>&amp;quot;bread&amp;quot; &amp;amp; &amp;quot;butter&amp;quot;</tt>.
	 *
	 * <p>
	 * 支持所有的已知的 HTML 4.0 entities.
	 * </p>
	 *
	 * @param str
	 *            需要进行HTML逃逸字符出来的字符串，可能为 null
	 * @return 返回已经进行逃逸处理后的字符串, 如果输入参数为null字符串则返回null
	 *
	 * @see #unescapeHtml(String)
	 * @see </br><a
	 *      href="http://hotwired.lycos.com/webmonkey/reference/special_characters/">ISO
	 *      Entities</a>
	 * @see </br><a href="http://www.w3.org/TR/REC-html32#latin1">HTML 3.2
	 *      Character Entities for ISO Latin-1</a>
	 * @see </br><a
	 *      href="http://www.w3.org/TR/REC-html40/sgml/entities.html">HTML 4.0
	 *      Character entity references</a>
	 * @see </br><a href="http://www.w3.org/TR/html401/charset.html#h-5.3">HTML
	 *      4.01 Character References</a>
	 * @see </br><a
	 *      href="http://www.w3.org/TR/html401/charset.html#code-position">HTML
	 *      4.01 Code positions</a>
	 */
	public static String escapeHtml(String str) {
		return StringEscapeUtils.escapeHtml(str);
	}

	/**
	 * 反逃逸操作(解码). 例如, 字符串 "&amp;lt;Fran&amp;ccedil;ais&amp;gt;" 操作后将返回
	 * "&lt;Fran&ccedil;ais&gt;" 如果entity不被识别,将逐字返回到结果字符串.
	 * 例："&amp;gt;&amp;zzzz;x" 将变为 "&gt;&amp;zzzz;x".
	 *
	 * @param str
	 *            将被反逃逸的字符串, 可能为 null
	 * @return 返回已经进行反逃逸处理后的字符串, 如果输入参数为null字符串则返回null
	 * @see #escapeHtml(String)
	 */
	public static String unescapeHtml(String str) {
		return StringEscapeUtils.unescapeHtml(str);
	}

	/**
	 * 使用XML entities中出现四个常用的字符，将字符串中的需要转换的字符全部逃逸.
	 *
	 * <p>
	 * 例如: <tt>"bread" & "butter"</tt> =>
	 * <tt>&amp;quot;bread&amp;quot; &amp;amp; &amp;quot;butter&amp;quot;</tt>.
	 * </p>
	 *
	 * <p>
	 * 仅支持逃逸这四个基本的 XML entities (gt, lt, quot, amp). 不支持 DTDs 或 扩展的实体(entities).
	 * </p>
	 *
	 * @param str
	 *            需要进行逃逸操作的字符串, 可能为 null
	 * @return 返回已经进行逃逸处理后的字符串, 如果输入参数为null字符串则返回null
	 * @see #unescapeXml(java.lang.String)
	 */
	public static String escapeXml(String str) {
		return StringEscapeUtils.escapeXml(str);
	}

	/**
	 * 将字符串中包含 XML entity 的部分转换成实际的相应的Unicode字符. 仅支持逃逸这四个基本的 XML entities (gt,
	 * lt, quot, amp). 不支持 DTDs 或 扩展的实体(entities).
	 *
	 * @param str
	 *            需要进行反逃逸操作的字符串, 可能为 null
	 * @return 返回已经进行反逃逸处理后的字符串, 如果输入参数为null字符串则返回null
	 * @see #escapeXml(String)
	 */
	public static String unescapeXml(String str) {
		return StringEscapeUtils.unescapeXml(str);
	}

	/**
	 * 把字符串中html标记所用的六个特殊字符替换回正常字符：&amp;quot;（&quot;） &amp;#039;（&#039;）
	 * &amp;lt;（&lt;） &amp;gt;（&gt;） &amp;amp;（&amp;） 。
	 *
	 * @param sSource
	 *            要替换的字符串。
	 * @return 返回替换后的字符串。
	 */
	public static String htmlDecode(String sSource) {
		String sTemp = sSource;
		sTemp = replace(sTemp, "&quot;", "\"");
		sTemp = replace(sTemp, "&#039;", "'");
		sTemp = replace(sTemp, "&lt;", "<");
		sTemp = replace(sTemp, "&gt;", ">");
		sTemp = replace(sTemp, "&amp;", "&");
		return sTemp;
	}

	/**
	 * 除去字符串中的所有逗号分割符（,）
	 *
	 * @param s
	 *            需要处理的字符串
	 * @return 不含有逗号的字符串
	 */
	public static String toToken(String s) {
		if (s == null || s.trim().equals(""))
			return s;
		String newStr = new String("");
		StringTokenizer st = new StringTokenizer(s, ",");
		while (st.hasMoreTokens()) {
			newStr = newStr + st.nextToken();
		}
		return newStr;
	}

	/**
	 * 除去字符串中的所有指定的分割符
	 *
	 * @param s
	 *            需要处理的字符串
	 * @return 不含有逗号的字符串
	 */
	public static String toToken(String s, String val) {
		if (s == null || s.trim().equals(""))
			return s;
		if (val == null || val.equals(""))
			return s;

		String newStr = new String("");
		StringTokenizer st = new StringTokenizer(s, val);
		while (st.hasMoreTokens()) {
			newStr = newStr + st.nextToken();
		}
		return newStr;
	}

	/**
	 * 将字符串左边的所有空格去掉。
	 *
	 * @param str：将要被处理的字符串
	 * @return 左边没有空格的字符串
	 */
	public static String leftTrim(String str) {
		if (str == null || str.equals(""))
			return str;

		StringBuffer sbf = new StringBuffer(str);
		while (sbf.charAt(0) == ' ') {
			sbf = sbf.deleteCharAt(0);
		}
		return sbf.toString();
	}

	/**
	 * 将字符串右边的所有空格去掉。
	 *
	 * @param str：将要被处理的字符串
	 * @return 右边没有空格的字符串
	 */
	public static String rightTrim(String str) {
		if (str == null || str.equals(""))
			return str;

		StringBuffer sbf = new StringBuffer(str);
		while (sbf.charAt(sbf.length() - 1) == ' ') {
			sbf = sbf.deleteCharAt(sbf.length() - 1);
		}
		return sbf.toString();
	}

	/**
	 * 将字符串反转。
	 *
	 * @param str:
	 *            将要反转的字符串。
	 * @return 返回经过反转处理的字符串。
	 */
	public static String reverseString(String str) {
		if (str == null || str.equals(""))
			return str;

		StringBuffer sbf = new StringBuffer(str);
		return sbf.reverse().toString();
	}

	/**
	 * 方法描述：主要用于cetree组装节点,如果字符串中含有'符号,在前台的js中会出现异常 该方法对含'的字符进行转换,供前台js使用,即把 '
	 * 转化为: \'
	 *
	 * @param str
	 * @return
	 */
	public static String convertStr(String str) {
		String s = str.replaceAll("\'", "\\\\'");
		return s;
	}

	/**
	 * 在字符串中替换html标记所用的六个特殊字符：& \ " ' &lt; &gt;
	 *
	 * @param sSource
	 *            要替换的字符串。
	 * @return 返回替换后的字符串。
	 */
	public static String htmlEncodeMessi(String sSource) {
		String sTemp = sSource;
		sTemp = replace(sTemp, "&", "&amp;");
		sTemp = replace(sTemp, "\"", "&quot;");
		sTemp = replace(sTemp, "'", "&#039;");
		sTemp = replace(sTemp, "<", "&lt;");
		sTemp = replace(sTemp, ">", "&gt;");
		sTemp = replace(sTemp, "\\", "\\\\");
		return sTemp;
	}

	/**
	 * 方法描述：单引号'反斜杠\双引号" -> 单引号&#039;反斜杠\\\\双引号\\&quot; 主要用于组装CETree的url时
	 * js参数中的字符串....使用方法如下: String test1 = "单引号'反斜杠\\双引号\""; String c =
	 * "javascript:changeHouseId(\"" +
	 * StringUtil.htmlEncode4CETreeJSParams(test2) + "\")"; node.setUrl(c);
	 *
	 * @param sSource
	 * @return
	 */
	public static String htmlEncode4CETreeJSParams(String sSource) {
		String sTemp = sSource;
		sTemp = replace(sTemp, "\\", "\\\\\\\\");
		sTemp = replace(sTemp, "\"", "\\\\&quot;");
		sTemp = replace(sTemp, "'", "&#039;");
		return sTemp;
	}

	public static String doHint(String str) {
		if (isContainAll(str)) {
			str = str.replaceAll("\"", "''");
		}
		return convertStr(str);
	}

	public static boolean isContainAll(String str) {
		if (str.indexOf("'") >= 0 && str.indexOf(">") >= 0) {
			if (str.indexOf("'") < str.indexOf(">")) {
				return true;
			}
			return false;
		}
		return false;
	}



}